#include "lvgl/lvgl.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <signal.h>
#include <errno.h>
#include <sys/stat.h>

#include "./../../inc/homePage.h"
#include "./../../inc/music.h"

// 音乐控制相关全局变量
static pid_t madplay_pid    = -1;         // madplay进程ID
int current_volume          = 70;         // 当前音量
int IS_PLAYING              = CLOSE_MODE; // 是否正在播放
int current_song            = 0;          // 当前播放索引
static int current_time_sec = 0;
static int total_time_sec   = 0;
lv_timer_t * progress_timer = NULL; // 进度条定时器

static int get_music_duration(const char * filename);

// 音乐文件列表
const char * music_files[] = {
    "res/music/yanyuan.mp3",
    "res/music/xiangfengyiyang.mp3",
    "res/music/guaika.mp3",
    "res/music/aiwohaishita.mp3",
    "res/music/aiwobiezou.mp3",
    "res/music/putongpengyou.mp3",
    "res/music/zenmeshuowobuaini.mp3",
    NULL // 结束标志
};

// 音乐文件名字
const char * music_names[] = {
    "演员-薛之谦",     "像风一样-薛之谦", "怪咖-薛之谦",           "爱我还是他-陶喆",
    "爱我别走-张震岳", "普通朋友-陶喆",   "怎么说我不爱你-萧敬腾", NULL // 结束标志
};

const char * home_music_names[] = {
    "演员", "像风一样", "怪咖", "爱我还是他", "爱我别走", "普通朋友", "怎么说我不爱你", NULL // 结束标志
};

const char * home_music_singer[] = {
    "薛之谦", "薛之谦", "薛之谦", "陶喆", "张震岳", "陶喆", "萧敬腾", NULL // 结束标志
};

// 当前播放的音乐图片
const char * music_imgs[] = {
    "S:res/music/yanyuan.png",
    "S:res/music/xiangfengyiyang.png",
    "S:res/music/guaika.png",
    "S:res/music/aiwohaishita.png",
    "S:res/music/aiwobiezou.png",
    "S:res/music/putongpengyou.png",
    "S:res/music/zenmeshuowobuaini.png",
    NULL // 结束标志
};

// 当前播放的音乐图片
const char * music_small_imgs[] = {
    "S:res/music/music_small/yanyuan.png",
    "S:res/music/music_small/xiangfengyiyang.png",
    "S:res/music/music_small/guaika.png",
    "S:res/music/music_small/aiwohaishita.png",
    "S:res/music/music_small/aiwobiezou.png",
    "S:res/music/music_small/putongpengyou.png",
    "S:res/music/music_small/zenmeshuowobuaini.png",
    NULL // 结束标志
};

// 更新播放/暂停图标
static void update_play_pause_icon(int is_playing, lv_obj_t * parent)
{
    if(is_playing == CLOSE_MODE) {
        IS_PLAYING = CLOSE_MODE;
        lv_img_set_src(home_open_close_img, "S:res/ui/open_music_w.png");
        pause_timer();
    } else {
        IS_PLAYING = OPEN_MODE;
        lv_img_set_src(home_open_close_img, "S:res/ui/close_music_w.png");
        resume_timer();
    }
    if(parent != home_page) {
        if(is_playing == CLOSE_MODE) {
            IS_PLAYING = CLOSE_MODE;
            lv_img_set_src(open_close_img, "S:res/ui/open_music_w.png");
        } else {
            IS_PLAYING = OPEN_MODE;
            lv_img_set_src(open_close_img, "S:res/ui/close_music_w.png");
        }
    }
}

// 停止当前播放
static void stop_music(lv_obj_t * parent)
{
    if(madplay_pid > 0) {
        int status;
        pid_t result;
        int timeout        = 500;                     // 总超时时间（ms）
        int interval       = 100;                     // 每次检查间隔（ms）
        struct timespec ts = {0, interval * 1000000}; // 100ms = 100*1e6纳秒

        // 步骤1：先恢复暂停的进程
        kill(madplay_pid, SIGCONT);
        usleep(10000); // 短暂等待，确保进程恢复运行

        // 步骤2：发送终止信号
        kill(madplay_pid, SIGTERM);

        // 步骤3：循环检查进程是否退出（非阻塞，总超时500ms）
        int elapsed = 0;
        do {
            result = waitpid(madplay_pid, &status, WNOHANG);
            if(result == 0) { // 进程仍在运行，等待间隔后重试
                nanosleep(&ts, NULL);
                elapsed += interval;
            }
        } while(result == 0 && elapsed < timeout);

        // 步骤4：超时未退出，强制杀死进程（兜底）
        if(result == 0) {
            kill(madplay_pid, SIGKILL);
            waitpid(madplay_pid, &status, 0); // 等待强制杀死完成
        }

        // 重置状态
        madplay_pid = -1;
        update_play_pause_icon(CLOSE_MODE, parent);

        if(progress_timer) {
            lv_timer_pause(progress_timer);
        }

        current_time_sec = 0;
        update_time_label();
    }
}

// 初始化音量
void set_system_volume(int vol)
{
    char cmd[128];
    snprintf(cmd, sizeof(cmd), "amixer set Master %d%% > /dev/null 2>&1", vol);
    system(cmd);
}

// 播放音乐
static void play_music(const char * file, lv_obj_t * parent)
{
    // 先停止当前播放
    stop_music(parent);

    // 停止进度定时器
    if(progress_timer) {
        lv_timer_pause(progress_timer);
    }

    // 重置时间
    current_time_sec = 0;
    total_time_sec   = get_music_duration(file);

    // 更新UI
    update_time_label();

    // 创建子进程执行madplay
    madplay_pid = fork();
    if(madplay_pid == 0) {
        execlp("madplay", "madplay", "-q", file, NULL);
        perror("execlp madplay failed");
        exit(EXIT_FAILURE);
    } else if(madplay_pid < 0) {
        lv_msgbox_create(NULL, "错误", "无法创建播放进程", NULL, false);
        madplay_pid = -1;
    } else {
        // 启动进度定时器
        if(!progress_timer) {
            progress_timer = lv_timer_create(progress_timer_cb, 1000, NULL);
        } else {
            lv_timer_resume(progress_timer);
        }

        update_play_pause_icon(OPEN_MODE, parent);
        resume_timer();
    }
}

// 上一曲按钮回调
void prev_event_cb(lv_event_t * e)
{
    lv_obj_t * parent = lv_event_get_user_data(e);
    if(!music_files[0]) return; // 无音乐文件

    // 计算上一曲索引（循环）
    if(current_song > 0) {
        current_song--;
    } else {
        // 找到最后一曲
        while(music_files[current_song + 1]) current_song++;
    }

    // 播放上一曲
    play_music(music_files[current_song], parent);
    change_music_picture();
}

// 播放/暂停按钮回调
void play_pause_event_cb(lv_event_t * e)
{
    lv_obj_t * parent  = lv_event_get_user_data(e);
    int process_exists = 0;

    // 检查进程是否真的存在且运行中（结合状态位校验）
    if(madplay_pid > 0) {
        int status;
        pid_t result = waitpid(madplay_pid, &status, WNOHANG);
        if(result == 0) {
            // 进程仍在运行，进一步判断是否处于暂停态
            if(waitpid(madplay_pid, &status, WUNTRACED | WNOHANG) == madplay_pid) {
                // 进程处于暂停态，更新状态位
                if(WIFSTOPPED(status)) {
                    IS_PLAYING = CLOSE_MODE;
                }
            }
            process_exists = 1;
        } else {
            // 进程已结束，强制重置所有状态
            madplay_pid    = -1;
            IS_PLAYING     = CLOSE_MODE;
            process_exists = 0;
        }
    }

    if(madplay_pid == -1 || !process_exists) {
        // 没有播放中的音乐，开始播放当前选中的
        if(music_files[current_song]) {
            play_music(music_files[current_song], parent);
        } else {
            lv_msgbox_create(NULL, "提示", "没有可播放的音乐", NULL, false);
        }
    } else {
        // 进程存在，切换暂停/继续状态
        if(IS_PLAYING == OPEN_MODE) {
            // 当前是播放状态，执行暂停
            if(kill(madplay_pid, SIGSTOP) == 0) {
                update_play_pause_icon(CLOSE_MODE, parent);
            }
        } else {
            // 当前是暂停状态，执行继续
            if(kill(madplay_pid, SIGCONT) == 0) {
                update_play_pause_icon(OPEN_MODE, parent);
            }
        }
    }
}

// 下一曲按钮回调
void next_event_cb(lv_event_t * e)
{
    lv_obj_t * parent = lv_event_get_user_data(e);
    if(!music_files[0]) return; // 无音乐文件

    // 计算下一曲索引（循环）
    if(music_files[current_song + 1]) {
        current_song++;
    } else {
        current_song = 0; // 循环到第一曲
    }

    // 播放下一曲
    play_music(music_files[current_song], parent);
    change_music_picture();
}

// 退出时清理音乐播放资源
void music_control_cleanup(lv_obj_t * parent)
{
    stop_music(parent);

    if(progress_timer) {
        lv_timer_del(progress_timer);
        progress_timer = NULL;
    }
}

// 更新时间标签
void update_time_label(void)
{
    char time_str[32];
    snprintf(time_str, sizeof(time_str), "%d:%02d / %d:%02d", current_time_sec / 60, current_time_sec % 60,
             total_time_sec / 60, total_time_sec % 60);
    if(music_time_label != NULL) lv_label_set_text(music_time_label, time_str);

    // 更新进度条值
    if(total_time_sec > 0) {
        int progress_value = (int)((float)current_time_sec / total_time_sec * 100);
        if(progress_bar) lv_slider_set_value(progress_bar, progress_value, LV_ANIM_OFF);
    }
}

// 获取文件的大小
unsigned long get_file_size_posix(const char * filename)
{
    struct stat st;
    if(stat(filename, &st) == 0) {
        return (unsigned long)st.st_size; // 返回字节数
    }
    return 0;
}
// 获取文件的比特率
unsigned long get_bitrate(const char * mp3_file)
{
    FILE * fp = fopen(mp3_file, "rb");
    if(!fp) return 0;

    // 跳过ID3标签
    unsigned char buf[10];
    if(fread(buf, 1, 10, fp) == 10 && !memcmp(buf, "ID3", 3)) {
        long size = ((buf[6] & 0x7F) << 21) | ((buf[7] & 0x7F) << 14) | ((buf[8] & 0x7F) << 7) | (buf[9] & 0x7F);
        fseek(fp, size + 10, SEEK_SET);
    } else {
        fseek(fp, 0, SEEK_SET);
    }

    // 查找MP3帧头
    while(fread(buf, 1, 4, fp) == 4) {
        if(buf[0] == 0xFF && (buf[1] & 0xE0) == 0xE0) break;
        fseek(fp, -3, SEEK_CUR);
    }

    // 解析比特率
    static const unsigned short bitrates[] = {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0};

    int idx = (buf[2] >> 4) & 0x0F;
    fclose(fp);

    return (idx < 16) ? bitrates[idx] : 0;
}

static int get_music_duration(const char * filename)
{
    int duration   = 0;
    int bitrate    = 0; // 从文件解析的比特率
    long file_size = 0;

    // 使用提供的posix方法获取文件大小
    file_size = get_file_size_posix(filename);
    if(file_size <= 0) {
        printf("文件大小为0或无法读取\n");
        duration = 180; // 默认3分钟
        return duration;
    }

    // 使用提供的方法获取MP3文件的比特率
    bitrate = get_bitrate(filename);
    if(bitrate > 0) {
        printf("检测到比特率: %d kbps\n", bitrate);
    } else {
        printf("无法解析比特率，使用默认值128kbps\n");
        bitrate = 128; // 默认比特率
    }

    // 使用公式计算时长: 时长(秒) = 文件大小(字节) * 8 / (比特率 * 1000)
    duration = (int)((file_size * 8.0) / (bitrate * 1000.0) + 0.5);
    printf("文件大小: %ld bytes, 比特率: %d kbps, 计算时长: %d 秒 (%d:%02d)\n", file_size, bitrate, duration,
           duration / 60, duration % 60);

    // 确保时长合理
    if(duration <= 0 || duration > 3600) { // 超过1小时，可能计算错误
        duration = 180;                    // 默认3分钟
        printf("计算时长异常，使用默认值: %d 秒\n", duration);
    }

    return duration;
}

// 进度定时器回调
void progress_timer_cb(lv_timer_t * timer)
{
    if(IS_PLAYING == OPEN_MODE && madplay_pid > 0) {
        current_time_sec++;

        if(current_time_sec > total_time_sec) {
            // 歌曲播放完毕，自动播放下一首
            current_time_sec  = 0;
            lv_obj_t * parent = lv_obj_get_parent(music_all_screen);
            // 这里需要修改，因为next_event_cb需要lv_event_t参数
            // 可以改为直接调用播放下一曲的逻辑
            if(music_files[current_song + 1]) {
                current_song++;
            } else {
                current_song = 0;
            }
            play_music(music_files[current_song], parent);
            change_music_picture();
        } else {
            update_time_label();
        }
    }
}